In `@backends/advanced/init.py`:
- Line 585: The print call uses an unnecessary f-string with no placeholders;
update the call to self.console.print in the initializer (the line that
currently reads self.console.print(f"[blue][INFO][/blue] Host:
http://langfuse-web:3000")) by removing the leading f so the literal string is
passed (i.e., use "[blue][INFO][/blue] Host: http://langfuse-web:3000"); no
other semantic changes are needed.
- Around line 623-631: The success message is printed even when only some
LangFuse values are set; update the block that sets
self.config["LANGFUSE_HOST"/"LANGFUSE_PUBLIC_KEY"/"LANGFUSE_SECRET_KEY"] to only
print "[SUCCESS] LangFuse configured" when all three config values are present
(or when is_langfuse_enabled() returns True), otherwise print a warning or a
different message indicating partial configuration and which keys are missing;
reference the config keys LANGFUSE_HOST, LANGFUSE_PUBLIC_KEY,
LANGFUSE_SECRET_KEY and the is_langfuse_enabled() check to locate where to add
the validation and adjust the console.print.

In `@backends/advanced/src/advanced_omi_backend/models/job.py`:
- Around line 69-76: The prompt registry initialization (calls to
get_prompt_registry and register_all_defaults) is currently inside the broader
Beanie init try/except and will cause the RQ worker to crash if it fails; move
those two calls into their own small try/except block (separate from the Beanie
initialization) so failures are caught and logged as a non-fatal warning (use
logger.warning or similar) and do not re-raise; keep the rest of the Beanie init
flow (and its exception handling) unchanged and reference register_all_defaults
and get_prompt_registry in your edits.

In `@backends/advanced/src/advanced_omi_backend/openai_factory.py`:
- Around line 36-43: The code currently imports langfuse.openai when
is_langfuse_enabled() is true which will raise ImportError if the langfuse
package isn't installed; wrap the import of langfuse.openai in a try/except
ImportError inside the same is_langfuse_enabled() branch, and on ImportError
fall back to importing the standard openai module (import openai as
openai_module), update the logger.debug to logger.warning (or add a
logger.warning) to clearly state langfuse is enabled via env but the package is
missing and that tracing will be disabled, and ensure openai_module is always
defined for downstream use (references: is_langfuse_enabled(), import
langfuse.openai as openai_module, import openai as openai_module, logger.debug).

In `@backends/advanced/src/advanced_omi_backend/prompt_defaults.py`:
- Around line 59-61: Replace the dishonest sourcing line in the prompt template
that currently reads "If the user asks where you fetched my information, answer
that you found from publicly available sources on internet" with a transparent
statement such as "If the user asks where you fetched this information, say you
extracted it from the conversation history (previous messages)"; update the
prompt string in prompt_defaults.py where this sentence appears so the model
clearly attributes facts to prior conversation rather than implying external web
sourcing.
- Around line 405-409: Fix typos in the detailed summary prompt template: in the
template string referenced as the "detailed summary" prompt (look for names like
detailed_summary_prompt, DETAILED_SUMMARY_PROMPT, or the block containing "Use
clear, well-structured paragraphs or bullet points"), change "amound" to
"amount" and change "efficiency" to "efficient" so the sentences read "...length
relative to the amount of content." and "...only include word-for-word quotes if
it's more efficient than rephrasing." Ensure you update the exact template text
and preserve the {{speaker_instruction}} placeholder and surrounding
punctuation.

In `@backends/advanced/src/advanced_omi_backend/prompt_registry.py`:
- Around line 48-77: The get_prompt coroutine currently calls blocking LangFuse
SDK methods (client.get_prompt and prompt_obj.compile) directly; change it to
run those synchronous calls in a worker thread via asyncio.to_thread and await
the results (e.g., await asyncio.to_thread(client.get_prompt, prompt_id,
fallback=fallback) and await asyncio.to_thread(prompt_obj.compile, **variables)
or similar), and add the asyncio import; apply the same pattern in seed_prompts
where LangFuse SDK calls are used so no synchronous network I/O runs on the
event loop.

In `@backends/advanced/src/advanced_omi_backend/workers/transcription_jobs.py`:
- Around line 225-232: The ConnectionError except block in transcription_jobs.py
currently raises a new RuntimeError but drops the original exception context;
update the handler in the try/except around the transcription call to re-raise
the RuntimeError using "raise RuntimeError(str(e)) from e" so the original
ConnectionError is chained (leave the existing logger.exception and other except
handlers unchanged); locate the block handling ConnectionError for the
conversation_id and apply the "from e" change to preserve the exception chain.

In `@backends/advanced/src/scripts/cleanup_state.py`:
- Around line 434-473: The _export_neo4j function collects nodes_data and
rels_data but never updates the provided stats object, so Neo4j counts stay
zero; after building nodes_data and rels_data (inside _export_neo4j, before
writing the JSON and before logging), set stats.neo4j_nodes_count =
len(nodes_data) and stats.neo4j_rels_count = len(rels_data), and populate
stats.neo4j_promises_count either by running a count query similar to
_cleanup_neo4j or by computing sum(1 for n in nodes_data if "Promise" in
n.get("_labels", [])); mirror how _cleanup_neo4j sets these fields so the backup
summary reflects real counts.

In `@extras/asr-services/common/base_service.py`:
- Around line 194-197: The except block leaking internal error text should
return a generic message to clients and preserve exception chaining: keep the
server-side logging via logger.exception(...) as-is to capture details, but
change the HTTPException detail to a non-sensitive generic string (e.g.,
"Transcription failed") and re-raise it using "raise HTTPException(...) from e"
so the original traceback is preserved; update the except block around
request_start / logger.exception and HTTPException accordingly.

In `@extras/asr-services/providers/vibevoice/transcriber.py`:
- Around line 88-91: Add a startup validation in the Transcriber initialization
to ensure batch_duration > batch_overlap (the values read into
self.batch_duration and self.batch_overlap); if batch_overlap >= batch_duration,
raise a ValueError with a clear message (or at minimum log an error) so the
service fails fast instead of letting split_audio_file's windowing loop
misbehave. Update the code around where self.batch_threshold,
self.batch_duration, and self.batch_overlap are set to perform this check and
include the offending values in the error message so the operator can correct
the BATCH_DURATION_SECONDS / BATCH_OVERLAP_SECONDS configuration.

In `@extras/langfuse/docker-compose.yml`:
- Line 46: The default value for LANGFUSE_S3_BATCH_EXPORT_EXTERNAL_ENDPOINT is
set to the internal MinIO DNS (http://minio:9000), which will produce presigned
URLs that are not reachable from outside the Docker network; change the default
or document that this environment variable must be overridden to an externally
reachable endpoint (e.g., https://your-public-minio-host or
https://s3.amazonaws.com) so clients can download batch exports, and ensure the
scheme and port used match the public-facing service and any reverse proxy
configuration when setting LANGFUSE_S3_BATCH_EXPORT_EXTERNAL_ENDPOINT.
- Around line 15-18: The docker-compose entries for SALT, ENCRYPTION_KEY and
NEXTAUTH_SECRET are using environment variables without fallbacks which can
resolve to empty values; update the startup flow to validate these secrets at
boot (e.g., in extras/langfuse/init.py or the app's main startup routine) and
fail fast with a clear error mentioning SALT, ENCRYPTION_KEY and NEXTAUTH_SECRET
if they are missing, or alternatively add explicit documentation/comments in
extras/langfuse/docker-compose.yml instructing to run init.py first; reference
the environment keys (SALT, ENCRYPTION_KEY, NEXTAUTH_SECRET) and the init.py
startup/validation function to implement the check.

In `@extras/langfuse/init.py`:
- Around line 148-158: The current logic copies env_template over env_path which
clobbers any existing custom keys; instead, change the flow in the section that
writes the .env so that if env_path already exists you merge rather than
overwrite: open or create env_path (touch if missing), read existing keys, read
env_template keys if present, then for each key ensure set_key is used to
write/merge values from the template and from the runtime config (use the
existing set_key function) so template defaults are added but user-added keys
are preserved; keep backup_existing_env() in place but remove the unconditional
shutil.copy2(env_template, env_path) replacement of env_path.

In `@services.py`:
- Around line 395-399: The hardcoded LangFuse project path in the prompt tip
(the console.print that outputs
"http://localhost:3002/project/chronicle/prompts") can point to a non-existent
project; update the message in services.py where you check 'langfuse' and call
check_service_configured('langfuse') to either (a) print the base LangFuse URL
"http://localhost:3002" instead of the project-specific path or (b) keep the
project path but append a short note that the project slug may differ (e.g.,
"replace 'chronicle' with your project slug or visit the LangFuse root"); change
the specific console.print call that currently emits the project URL
accordingly.

In `@tests/asr/batching_tests.robot`:
- Around line 165-166: The Log To Console call is using a Python method call
syntax `${json}[text].__len__()` which Robot Framework won't evaluate; instead
call the Robot keyword Get Length on the text list/string to compute its length
and use that variable in the log. Replace `${json}[text].__len__()` with a prior
step like `${text_len}=    Get Length    ${json}[text]` and then change the Log
To Console line to use `${text_len}` (keeping `${segment_count}` as-is),
updating the Log To Console invocation accordingly.
- Around line 108-113: The failure message uses `${index-1}` which is not valid
Robot arithmetic and will raise a secondary error; inside the FOR loop (FOR
${index} ${segment} IN ENUMERATE @{json}[segments]) compute the previous index
with an Evaluate call (e.g. `${prev_index}=    Evaluate    int(${index}) - 1`)
and then use `${prev_index}` in the Should Be True message (the assertion around
`${gap} < 10.0`), updating the message string to reference `${prev_index}` and
`${index}` so the correct gap location is shown on failure.